#!/usr/bin/env node

import fs from 'fs';
import path from 'path';
import { fileURLToPath } from 'url';
import chalk from 'chalk';
import {createLogger} from "./utils/Logger.js";
import {AutoUpdater} from "./utils/AutoUpdater.js";
import process from "process";

/**
 * 通用命令行工具路由器
 * 根据执行的命令名自动路由到对应的处理文件
 */
class CommandRouter {
    constructor() {
        // ES6 模块中获取 __dirname
        const __filename = fileURLToPath(import.meta.url);
        const __dirname = path.dirname(__filename);

        this.scriptDir = __dirname;
        this.commandsDir = path.join(this.scriptDir, 'commands');
        this.logger = createLogger('SYSTEM');
        this._consumedCommandArg = false;
        this.autoUpdater = new AutoUpdater({
            repoDir: this.scriptDir,
            logger: this.logger
        });
        this.commandName = this.resolveCommandName();
    }

    resolveCommandName() {
        if (process.env.NIKOU_ENTRY_COMMAND) {
            return process.env.NIKOU_ENTRY_COMMAND;
        }
        const invokedScript = process.argv[1] || '';
        const baseName = path.basename(invokedScript);
        const withoutExt = baseName.endsWith('.js') ? baseName.slice(0, -3) : baseName;
        if (withoutExt === 'router') {
            const maybeCommand = process.argv[2];
            if (maybeCommand && !maybeCommand.startsWith('-')) {
                const potentialFile = path.join(this.commandsDir, `${maybeCommand}.js`);
                if (fs.existsSync(potentialFile)) {
                    this._consumedCommandArg = true;
                    return maybeCommand;
                }
            }
            return 'nb';
        }
        return withoutExt;
    }

    /**
     * 路由到对应的命令处理器
     */
    async route() {
        try {
            // 构建命令处理文件路径
            const commandFile = path.join(this.commandsDir, `${this.commandName}.js`);
            const logger = this.logger;

            await this.autoUpdater.run();

            // 检查命令文件是否存在
            if (!fs.existsSync(commandFile)) {
                console.error(chalk.red(`❌ 错误: 未找到命令 '${this.commandName}' 的处理器`));
                console.error(chalk.gray(`预期文件位置: ${commandFile}`));
                await this.showAvailableCommands();
                process.exit(1);
            }

            // 动态导入命令处理器 (ES6 模块)
            const commandHandler = await import(`file://${commandFile}`);

            // 验证处理器格式
            if (typeof commandHandler.execute !== 'function') {
                console.error(chalk.red(`❌ 错误: ${this.commandName}.js 必须导出 execute 函数`));
                process.exit(1);
            }

            // 传递原始命令行参数给处理器（去除 node 和脚本路径）
            const argsOffset = this._consumedCommandArg ? 3 : 2;
            const args = process.argv.slice(argsOffset);

            // 显示路由信息（调试模式）
            logger.debug(`路由到: ${this.commandName} 处理器`)
            logger.debug(`参数: ${args.join(' ')}`)

            // 执行命令处理器
            await commandHandler.execute(args);

        } catch (error) {
            console.error(chalk.red(`❌ 执行 ${this.commandName} 时发生错误:`), error.message);
            if (process.env.DEBUG) {
                console.error(chalk.gray('详细错误信息:'), error.stack);
            }
            process.exit(1);
        }
    }

    /**
     * 显示可用的命令
     */
    async showAvailableCommands() {
        try {
            if (!fs.existsSync(this.commandsDir)) {
                this.logger.warn('commands 目录不存在，请创建相应的命令处理器');
                return;
            }

            const commands = fs.readdirSync(this.commandsDir)
                .filter(file => file.endsWith('.js'))
                .map(file => path.basename(file, '.js'));

            if (commands.length > 0) {
                this.logger.info('可用命令:');
                commands.forEach(cmd => {
                    console.log(`  • ${cmd}`);
                });
                this.logger.info('请确保命令文件名与执行的命令名一致');
            } else {
                this.logger.warn('commands 目录为空，请添加命令处理器');
            }
        } catch (error) {
            this.logger.error('获取可用命令时出错:', error.stack);
        }
    }
}

// 主执行逻辑
async function main() {
    const router = new CommandRouter();
    await router.route();
}

// 异常处理
process.on('uncaughtException', (error) => {
    const logger = createLogger('SYSTEM');
    logger.error('未捕获的异常:', error.message);
    process.exit(1);
});

process.on('unhandledRejection', (reason, promise) => {
    const logger = createLogger('SYSTEM');
    logger.error('未处理的 Promise 拒绝:', reason);
    process.exit(1);
});

// 启动应用
main().catch(error => {
    const logger = createLogger('SYSTEM');
    logger.error('应用启动失败:', error.message);
    process.exit(1);
});
